# 层序遍历就是逐层遍历树结构。
"""
广度优先搜索是一种广泛运用在树或图这类数据结构中，遍历或搜索的算法。 该算法从一个根节点开始，
首先访问节点本身。 然后遍历它的相邻节点，其次遍历它的二级邻节点、三级邻节点，以此类推。
当我们在树中进行广度优先搜索时，我们访问的节点的顺序是按照层序遍历顺序的。
"""


# BFS 通用模板
"""
BFS
BFS使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS总共有两个模板：

1.如果不需要确定当前遍历到了哪一层，BFS模板如下。

while queue 不空：
    cur = queue.pop()
    for 节点 in cur的所有相邻节点：
        if 该节点有效且未访问过：
            queue.push(该节点)

2.如果要确定当前遍历到了哪一层，BFS模板如下。
这里增加了level表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。
size表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
                queue.push(该节点)
    }
    level ++;
上面两个是通用模板，在任何题目中都可以用，是要记住的！

作者：fuxuemingzhu
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/tao-mo-ban-bfs-he-dfs-du-ke-yi-jie-jue-by-fuxuemin/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
"""


# 例子
"""
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

 

示例：
二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/data-structure-binary-tree/xefh1i/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
"""
from collections import deque


class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def levelOrder(self, root: TreeNode):
        r = []
        self.level(root, 0, r)
        return r

    def level(self, node: TreeNode, level, res):
        if not node:
            return
        if len(res) == level:
            res.append([])
        res[level].append(node.val)
        if node.left:
            self.level(node.left, level+1, res)
        if node.right:
            self.level(node.right, level+1, res)

    def level_order(self, root: TreeNode):
        queue = deque()
        queue.append(root)
        res = []
        while queue:
            size = len(queue)
            level = []
            for i in range(size):
                cur = queue.popleft()
                if not cur:
                    level.append('null')
                    continue
                level.append(cur.val)
                queue.append(cur.left)
                queue.append(cur.right)
            if level:
                res.append(level)
        return res

    # 蛇形打印
    def levelOrder2(self, root: TreeNode):
        if not root:
            return []
        queue = deque()
        queue.append(root)
        res = []
        while queue:
            size = len(queue)
            level = []
            for i in range(size):
                cur = queue.popleft()
                if len(res) % 2 > 0:
                    level.insert(0, cur.val)
                else:
                    level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            if level:
                res.append(level)
        return res

    # 横向打印
    def levelOrder3(self, root: TreeNode):
        if not root:
            return []
        queue = deque()
        queue.append(root)
        r = []
        while queue:
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                r.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return r


if __name__ == '__main__':
    tree = TreeNode(3)
    tree.left = TreeNode(9)
    tree.right = TreeNode(20)
    tree.right.left = TreeNode(15)
    tree.right.right = TreeNode(7)
    s = Solution()
    print(s.levelOrder(tree))
    print(s.level_order(tree))
    print(s.levelOrder2(tree))
    print(s.levelOrder3(tree))
